(a) printf() and scanf()

(a) for and do-while loops

(b) switch and if-else-if statements.

(a) Union and Structure

(b) Scope and lifetime of a variable

When writing computer programs, it is essential to represent logic in a clear and organized

way. Two common tools for doing this are decision tables and flowcharts. While both serve

the purpose of illustrating processes or decisions, they do so in different ways and are

suited for different scenarios. Let us explore these tools in detail.

A decision table is a structured way of representing a set of rules or conditions and their

corresponding actions. It organizes information in a tabular form, making it easier to

visualize and understand complex decision-making scenarios. Decision tables are especially

conditions.

condition alternatives.

corresponding actions.

A flowchart is a visual representation of a process or system using symbols, shapes, and

arrows. It shows the sequence of steps in a process, helping to understand how decisions

and actions flow from one step to another. Flowcharts are commonly used to illustrate

algorithms, workflows, or system operations.

(Start) --> [Is it raining?] --> Yes --> [Have umbrella?] --> Yes --> (Go outside)

| |

No -----------------------------> (Stay inside)

No --> (Go outside)

Handling complex decision-

making

Illustrating the flow of processes

decisions lead to actions.

Think of a decision table as a checklist for packing your bags. You consider conditions like

weather, duration, and type of trip, and then decide what to pack. On the other hand, a

flowchart is like a map that shows the route to your destination, including turns and stops

along the way.

Both decision tables and flowcharts are invaluable tools in programming and system design.

Decision tables excel at organizing complex logic with multiple conditions, while flowcharts

Before diving into the conversion process, let's briefly understand the four number systems

we'll be dealing with:

to 'F,' which is 15.

To solidify our understanding, lets use an analogy:

Imagine you have a recipe written in a different language (hexadecimal). To cook the dish,

(octal), and another friend's language (binary). Each conversion ensures everyone

understands and can follow the recipe correctly.

precedence.

int x = 5;

int y = ++x; // Prefix: x becomes 6, then y is assigned 6

int z = x--; // Postfix: z is assigned 6, then x becomes 5

int result = 8 << 1; // Left shifts 8 by 1 bit, result is 16

int isEqual = (5 == 5); // Evaluates to 1 (true)

int isNotEqual = (5 != 3); // Evaluates to 1 (true)

int result = 5 & 3; // Performs bitwise AND, result is 1

int result = 5 ^ 3; // XOR: 5 (101) ^ 3 (011) = 6 (110)

int result = (5 > 3) && (10 > 5); // True && True = 1

int x = 5;

x += 3; // x = x + 3; now x is 8

int x, y;

x = (y = 3, y + 2); // y = 3, then x = y + 2 = 5

1. Operators with higher precedence are executed before those with lower

evaluation.

int result = 10 + 5 * 2 > 15 && 20 / 5 == 4;

Understanding the hierarchy of operators is essential for writing clear and accurate code. By

knowing the precedence and associativity, you can predict how expressions will be

evaluated and avoid logical errors in your programs. Use parentheses ( ) to group parts of

also ensures the correct order of execution.

The name "C" for the programming language has an interesting and straightforward origin.

level programming.

The name "C" reflects its position as a successor to "B" and symbolizes its evolution from

data types and structures. This enhanced flexibility and efficiency, leading to the

creation of C.

C quickly became popular because of its simplicity, portability (ability to work on different

systems), and ability to provide low-level access to hardware while remaining readable.

A C program has a well-defined structure. Think of it as a recipe for cookingit has specific

steps, ingredients (data), and tools (functions) to achieve a task. Let's explore the structure

step-by-step.

#include <stdio.h> // Preprocessor Directive

num = 5;

Lets break it down:

compilation.

wouldnt have access to many essential tools in C.

Variables are like labeled jars in a kitchen where you store ingredients (e.g., sugar, salt). In C,

int for integers, float for decimals, char for characters).

recipes (functions) for specific tasks.

void greet() {

printf("Hello, World!");

Control statements are decision-makers. Think of them as the if-else situations in life.

if (age >= 18) {

printf("You are eligible to vote.");

} else {

Loops are repetitive tasks, like stirring soup in a pot until it boils.

Comments are notes written in the program for the programmers understanding. The

computer ignores them.

int main() { // Main function

int num; // Declare variable

printf("Enter a number: ");

scanf("%d", &num); // Input from user

if (num % 2 == 0) { // Check if the number is even

printf("%d is an even number.\n", num);

} else {

printf("%d is an odd number.\n", num);

(a) printf() and scanf()

play a significant role in enabling communication between a program and its user.

Output:

for (int i = 0; i < 5; i++) {

printf("Mark %d: %d\n", i + 1, marks[i]);

}

return 0;

}

1. All elements in a 1D array are of the same data type.

2. The size of the array must be specified while declaring it.

3. Array indexing starts from 0.

A 2D array is like a table with rows and columns. It is used to store data in a grid or matrix

int matrix[2][3]; // Creates a 2D array with 2 rows and 3 columns.

#include <stdio.h>

int main() {

int matrix[2][3] = { {1, 2, 3}, {4, 5, 6} };

// Accessing and printing elements

printf("First row, second column: %d\n", matrix[0][1]); // Output: 2

printf("Second row, third column: %d\n", matrix[1][2]); // Output: 6

Using Loops with a 2D Array

To print all elements of a 2D array, you can use nested loops (a loop inside another loop):

#include <stdio.h>

int main() {

int matrix[2][3] = { {1, 2, 3}, {4, 5, 6} };

return 0;

}

1 2 3

4 5 6

access values efficiently.

This explanation simplifies the concept of arrays, covers their types, and includes relevant

string when it is created. It acts as a terminator, indicating where the string ends.

example:

In C, strings are not a built-in data type like integers or floats. Instead, strings are stored in

an array of characters. This means that a string is simply a collection of characters arranged

one after another in memory.

char myString[] = "Hello";

\0 at the end.

How Strings are Stored in C

When you store a string "Hello" in memory, it looks like this:

The strlen() function calculates the length of a string (the number of characters before the

#include <stdio.h>

csharp

The length of the string is: 5

Here, the function ignores the null character at the end of the string.

strcpy(destination, source); // Copies "Hello" into destination

printf("Copied string: %s", destination);

return 0;

}

char *strcat(char *destination, const char *source);

#include <stdio.h>

#include <string.h>

int main() {

char str1[20] = "Hello ";

char str2[] = "World!"

strcat(str1, str2); // Appends str2 to str1

printf("Concatenated string: %s", str1);

int strcmp(const char *str1, const char *str2);

#include <stdio.h>

#include <string.h>

else

printf("Strings are not equal.");

return 0;

}

The strrev() function reverses a string. Note that this is not part of the standard library but is

strrev(str);

printf("Reversed string: %s", str);

return 0;

}

Imagine you are creating a program to store the names of five friends. You can use an array

of strings.

#include <stdio.h>

int main() {

// Array of strings

char friends[5][20] = {

"Alice",

"Bob",

}

return 0;

}

Friend 5: Eve

Think of a string as a single word written on a piece of paper.

Now, imagine an array of strings as a book containing multiple words or sentences.

1. A string is a sequence of characters terminated by a null character \0.

2. String functions like strlen(), strcpy(), strcat(), and strcmp() help you perform

with collections of text data.

(a) for and do-while loops

(b) switch and if-else-if statements.

they execute and handle conditions. Let's explore their differences in a detailed and easy-to-

for (int i = 1; i <= 5; i++) {

printf("Value of i: %d\n", i);

}

union Data myData;

myData.i = 10; // Store an integer

printf("Integer: %d\n", myData.i);

myData.f = 20.5; // Store a float (overwrites the integer)

When you write a program, variables have a scope and a lifetime, which determine where

and how long the variable can be used.

The scope of a variable defines where in the program you can access or use it. Its like a

boundary. There are three main types of scope:

void func1() {

printf("Global variable: %d\n", globalVar);

}

void func2() {

globalVar += 5;

printf("Global variable updated: %d\n", globalVar);

}

if (1) {

int blockVar = 30; // Block-scoped variable

printf("Block variable: %d\n", blockVar);

void staticExample() {

static int count = 0; // Static variable

count++;

printf("Count: %d\n", count);

}

Recursion is when a function calls itself to solve a smaller part of a problem. Its like standing

the original.

such as calculating factorials, Fibonacci numbers, or traversing a directory.

calling itself indefinitely, causing an error.

if (n == 0) // Base case

return 1;

else

ones: 0, 1, 1, 2, 3, 5, 8...

int fibonacci(int n) {

if (n == 0) // Base case

return 0;

else if (n == 1) // Base case

reach the top.

changes made inside the function do not affect the original value.

write on the photocopy (function). The changes appear only on the photocopy, not

on the original document.

void modifyValue(int &x) {

x = x + 10; // Modifies the original value

}

function is running. They are created when the function starts and destroyed when

the function ends.

void demo() {

int x = 10; // Automatic variable

functions and can be accessed and modified by any function in the program.

family can access and change.

void demo() {

x++;

printf("%d", x); // Output: 11

}

int main() {

demo();

return 0;

}

over (function ends), the food (variable) remains until you use it again.

void demo() {

static int x = 10; // Static variable

x++;

printf("%d", x);

a program.

You decide how it works, what it does, and when to use it.

int main() {

int result = add(5, 10); // Output: 15

return 0;

}